.TH std::shared_lock::shared_lock 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::shared_lock::shared_lock \- std::shared_lock::shared_lock

.SH Synopsis
   shared_lock() noexcept;                                            \fB(1)\fP \fI(since C++14)\fP
   shared_lock( shared_lock&& other ) noexcept;                       \fB(2)\fP \fI(since C++14)\fP
   explicit shared_lock( mutex_type& m );                             \fB(3)\fP \fI(since C++14)\fP
   shared_lock( mutex_type& m, std::defer_lock_t t ) noexcept;        \fB(4)\fP \fI(since C++14)\fP
   shared_lock( mutex_type& m, std::try_to_lock_t t );                \fB(5)\fP \fI(since C++14)\fP
   shared_lock( mutex_type& m, std::adopt_lock_t t );                 \fB(6)\fP \fI(since C++14)\fP
   template< class Rep, class Period >

   shared_lock( mutex_type& m,                                        \fB(7)\fP \fI(since C++14)\fP

                const std::chrono::duration<Rep,Period>&
   timeout_duration );
   template< class Clock, class Duration >

   shared_lock( mutex_type& m,                                        \fB(8)\fP \fI(since C++14)\fP

                const std::chrono::time_point<Clock,Duration>&
   timeout_time );

   Constructs a shared_lock, optionally locking the supplied mutex.

   1) Constructs a shared_lock with no associated mutex.
   2) Move constructor. Initializes the shared_lock with the contents of other. Leaves
   other with no associated mutex.
   3-8) Constructs a shared_lock with m as the associated mutex. Additionally:
   3) Locks the associated mutex in shared mode by calling m.lock_shared().
   4) Does not lock the associated mutex.
   5) Tries to lock the associated mutex in shared mode without blocking by calling
   m.try_lock_shared().
   6) Assumes the calling thread already holds a shared lock (i.e., a lock acquired by
   lock_shared, try_lock_shared, try_lock_shared_for, or try_lock_shared_until) on m.
   The behavior is undefined if not so.
   7) Tries to lock the associated mutex in shared mode by calling
   m.try_lock_shared_for(timeout_duration), which blocks until specified
   timeout_duration has elapsed or the lock is acquired, whichever comes first. May
   block for longer than timeout_duration. The behavior is undefined if Mutex does not
   meet the SharedTimedLockable requirements.
   8) Tries to lock the associated mutex in shared mode by calling
   m.try_lock_shared_until(timeout_time), which blocks until specified timeout_time has
   been reached or the lock is acquired, whichever comes first. May block for longer
   than until timeout_time has been reached. The behavior is undefined if Mutex does
   not meet the SharedTimedLockable requirements.

.SH Parameters

   other            - another shared_lock to initialize the state with
   m                - mutex to associate with the lock and optionally acquire ownership
                      of
   t                - tag parameter used to select constructors with different locking
                      strategies
   timeout_duration - maximum duration to block for
   timeout_time     - maximum time point to block until

.SH Example


// Run this code

 #include <chrono>
 #include <iostream>
 #include <shared_mutex>
 #include <syncstream>
 #include <thread>

 std::shared_timed_mutex m;
 int i = 10;

 void read_shared_var(int id)
 {
      // both the threads get access to the integer i
      std::shared_lock<std::shared_timed_mutex> slk(m);
      const int ii = i; // reads global i

      std::osyncstream(std::cout) << '#' << id << " read i as " << ii << "...\\n";
      std::this_thread::sleep_for(std::chrono::milliseconds(10));
      std::osyncstream(std::cout) << '#' << id << " woke up..." << std::endl;
 }

 int main()
 {
      std::thread r1{read_shared_var, 1};
      std::thread r2{read_shared_var, 2};

      r1.join();
      r2.join();
 }

.SH Possible output:

 #2 read i as 10...
 #1 read i as 10...
 #2 woke up...
 #1 woke up...
